﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Linq.Expressions;
//using System.Text;
//using System.Web;
//using System.Web.Mvc;
//using System.Web.Mvc.Html;

//namespace KeyCore.Loans.Client.Web.Infrastructure
//{
//    public static class HtmlHelpers
//    {

//        public static MvcHtmlString HiddenInputFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, object htmlAttributes = null)
//        {
//            IDictionary<string, object> htmlAttributesTmp = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
//            if (htmlAttributesTmp.ContainsKey("type"))
//            {
//                htmlAttributesTmp["type"] = "hidden";
//            }
//            else
//            {
//                htmlAttributesTmp.Add("type", "hidden");
//            }

//            return html.TextBoxFor(expression, htmlAttributesTmp);
//        }

//        private static MvcHtmlString DisplayNameFor<TModel, TProperty>(Expression<Func<TModel, TProperty>> expression)
//        {
//            var metadata = ModelMetadata.FromLambdaExpression<TModel, TProperty>(expression, new ViewDataDictionary<TModel>());
//            var htmlFieldName = ExpressionHelper.GetExpressionText(expression);
//            string s = metadata.DisplayName ?? (metadata.PropertyName ?? htmlFieldName.Split(new char[] { '.' }).Last<string>());
//            return new MvcHtmlString(HttpUtility.HtmlEncode(s));
//        }

//        public static MvcHtmlString DisplayNameFor<TModel, TProperty>(this HtmlHelper<IEnumerable<TModel>> helper, Expression<Func<TModel, TProperty>> expression)
//        {
//            var name = ExpressionHelper.GetExpressionText(expression);
//            name = helper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
//            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => Activator.CreateInstance<TModel>(), typeof(TModel), name);
//            return new MvcHtmlString(metadata.DisplayName);
//        }
//        /// <summary>
//        /// Dropdowns for enums. @Html.EnumDropDownListFor(m =&gt; m.Sex)
//        /// @Html.DropDownListFor(m => m.CategoryId,
//        /// (IEnumerable<SelectListItem>)ViewBag.CategoryList, 
//        /// "--Please select--")
//        /// </summary>
//        public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper,
//            Expression<Func<TModel, TEnum>> expression)
//        {
//            var metadata =
//                ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

//            var nonNullableType = metadata.ModelType;
//            var underlyingType = Nullable.GetUnderlyingType(nonNullableType);
//            if (underlyingType != null)
//            {
//                nonNullableType = underlyingType;
//            }

//            var items = (from value in
//                             Enum.GetValues(nonNullableType).Cast<TEnum>()
//                         select new SelectListItem
//                         {
//                             Text = value.ToString(), //could look for [Description] attribute
//                             Value = value.ToString(), //default binder can use string
//                             Selected = value.Equals(metadata.Model)
//                         }).ToList();

//            if (metadata.IsNullableValueType)
//            {
//                var empty = new SelectListItem { Text = string.Empty, Value = string.Empty };
//                items.Insert(0, empty);
//            }

//            return htmlHelper.DropDownListFor(expression, items);
//        }

//        public static MvcHtmlString EnumRadioListFor<TModel, TEnum>(
//            this HtmlHelper<TModel> htmlHelper,
//            Expression<Func<TModel, TEnum>> expression)
//        {
//            var metadata =
//                ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
//            var nonNullableType = metadata.ModelType;
//            var underlyingType = Nullable.GetUnderlyingType(nonNullableType);
//            if (underlyingType != null)
//            {
//                nonNullableType = underlyingType;
//            }

//            var names = Enum.GetNames(nonNullableType);
//            var sb = new StringBuilder();
//            //respect the hierarchy
//            var prefix = htmlHelper.ViewData.TemplateInfo.HtmlFieldPrefix;
//            if (string.IsNullOrWhiteSpace(prefix))
//                prefix = null;
//            else
//                prefix += "_";
//            foreach (var name in names)
//            {
//                //id is format "propertyName_enum". 
//                var id = string.Format("{0}{1}_{2}",
//                                prefix,
//                                metadata.PropertyName,
//                                name);
//                //use the standard template and turn it into a string
//                var radio = htmlHelper.RadioButtonFor(expression, name, new { id })
//                    .ToHtmlString();
//                sb.AppendFormat("<label for=\"{0}\">{1}</label> {2}",
//                                id,
//                            HttpUtility.HtmlEncode(name),
//                                radio);
//            }
//            return MvcHtmlString.Create(sb.ToString());
//        }


//        //public static MvcHtmlString FullFieldEditor<T, TValue>(this HtmlHelper<T> html, Expression<Func<T, TValue>> expression)
//        //{
//        //    return FullFieldEditor(html, expression, null);
//        //}

//        //public static MvcHtmlString FullFieldEditor<T, TValue>(this HtmlHelper<T> html, Expression<Func<T, TValue>> expression, object htmlAttributes)
//        //{
//        //    var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);

//        //    if (!metadata.ShowForEdit)
//        //    {
//        //        return MvcHtmlString.Empty;
//        //    }

//        //    if (metadata.HideSurroundingHtml)
//        //    {
//        //        return html.EditorFor(expression);
//        //    }

//        //    var wrapper = new TagBuilder("div");
//        //    wrapper.AddCssClass("field-wrapper");

//        //    var table = new TagBuilder("table");
//        //    table.Attributes["border"] = "0";

//        //    //added this to even out table columns
//        //    table.Attributes["width"] = "100%";

//        //    var tbody = new TagBuilder("tbody");

//        //    var td1 = new TagBuilder("td");
//        //    td1.Attributes["width"] = "40%";
//        //    td1.Attributes["valign"] = "top";

//        //    var label = new TagBuilder("div");
//        //    label.AddCssClass("field-label");
//        //    label.AddCssClass("mylabelstyle");
//        //    label.InnerHtml += html.MyLabelFor(expression);

//        //    td1.InnerHtml = label.ToString();

//        //    var td2 = new TagBuilder("td");
//        //    td2.Attributes["width"] = "50%";
//        //    td2.Attributes["valign"] = "top";

//        //    var input = new TagBuilder("div");
//        //    input.AddCssClass("field-input");

//        //    // option1
//        //    input.InnerHtml += html.EditorFor(expression, htmlAttributes);
//        //    td2.InnerHtml = input.ToString();

//        //    var td3 = new TagBuilder("td");
//        //    td3.Attributes["width"] = "5%";
//        //    td3.Attributes["valign"] = "top";

//        //    if (metadata.IsRequired && !metadata.IsReadOnly)
//        //    {
//        //        // option2
//        //        td3.InnerHtml += html.RequiredFor(expression, htmlAttributes);
//        //    }

//        //    var td4 = new TagBuilder("td");
//        //    td4.Attributes["width"] = "5%";
//        //    td4.Attributes["valign"] = "middle";

//        //    if (!string.IsNullOrEmpty(metadata.Description))
//        //    {
//        //        td4.InnerHtml += html.TooltipFor(expression);
//        //    }
//        //    else
//        //    {
//        //        td4.InnerHtml += html.SpacerFor(expression);
//        //    }

//        //    td4.InnerHtml += html.ValidationMessageFor(expression);

//        //    var tr = new TagBuilder("tr");
//        //    tr.InnerHtml = td1.ToString() + td2.ToString() + td3.ToString() + td4.ToString();

//        //    tbody.InnerHtml = tr.ToString();
//        //    table.InnerHtml = tbody.ToString();
//        //    wrapper.InnerHtml = table.ToString();

//        //    return new MvcHtmlString(wrapper + Environment.NewLine);
//        //}


//             //<%@ Import Namespace="MvcApplication2" %>
//            //<%=Html.HtmlIdNameFor(m=>m.Customer.Name)%>
//            public static string HtmlIdNameFor<TModel, TValue>(
//                this HtmlHelper<TModel> htmlHelper,
//                System.Linq.Expressions.Expression<Func<TModel, TValue>> expression)
//            {
//                return (GetHtmlIdNameFor(expression));
//            }

//            private static string GetHtmlIdNameFor<TModel, TValue>(Expression<Func<TModel, TValue>> expression)
//            {
//                if (expression.Body.NodeType == ExpressionType.Call)
//                {
//                    var methodCallExpression = (MethodCallExpression)expression.Body;
//                    string name = GetHtmlIdNameFor(methodCallExpression);
//                    return name.Substring(expression.Parameters[0].Name.Length + 1).Replace('.', '_');

//                }
//                return expression.Body.ToString().Substring(expression.Parameters[0].Name.Length + 1).Replace('.', '_');
//            }

//            private static string GetHtmlIdNameFor(MethodCallExpression expression)
//            {
//                var methodCallExpression = expression.Object as MethodCallExpression;
//                if (methodCallExpression != null)
//                {
//                    return GetHtmlIdNameFor(methodCallExpression);
//                }
//                return expression.Object.ToString();
//            }

//        //@Html.ClientIdFor(model=>model.client.email)
//            public static MvcHtmlString ClientIdFor<TModel, TProperty>(
//                this HtmlHelper<TModel> htmlHelper,
//                Expression<Func<TModel, TProperty>> expression)
//            {
//                return MvcHtmlString.Create(
//                      htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldId(
//                          ExpressionHelper.GetExpressionText(expression)));
//            }

//        public static MvcHtmlString EditorFor<TModel, TProperty>(this HtmlHelper<TModel> helper, Expression<Func<TModel, TProperty>> expression, TemplateOptions options)
//        {
//            return helper.EditorFor(expression, options.TemplateName, new
//            {
//                cssClass = options.CssClass
//            });
//        }
//    }

//    public class TemplateOptions
//    {
//        public string TemplateName { get; set; }
//        public string CssClass { get; set; }
//        // other properties for info you'd like to pass to your templates,
//        // and by using an options object, you avoid method overload bloat.
//    }
//}